1. Field of the Invention
The present invention relates generally to a channel communication apparatus and method for a CDMA communication system, and in particular, to an apparatus and method for allocating OVSF codes for channel separation in a CDMA communication system.
2. Description of the Related Art
A CDMA (Code Division Multiple Access) communication system uses orthogonal codes (or orthogonal variable spreading factor (OVSF) codes) for channel separation, and the CDMA system is divided into a synchronous CDMA system and an asynchronous CDMA system. Herein, the present invention will be described with reference to an asynchronous CDMA communication system, which is typically called a W-CDMA (Wideband CDMA) or UMTS (Universal Mobile Terrestrial System) communication system. Specifically, a description will be made of an operation of allocating channels using OVSF codes in the W-CDMA communication system. However, the present invention can also be applied to a synchronous CDMA communication system such as a CDMA-2000 system.
FIG. 1 shows an architecture of a W-CDMA communication system. As shown in FIG. 1, every process for connection of a user equipment (UE) is controlled by a radio network controller (RNC or a base station controller (BSC) in the CDMA-2000 system). Further, allocation of resources to the UEs connected to base station transceivers (or Node B) is also controlled by the RNC which manages the base station transceivers (BTSs).
When a UE intends to use a common packet channel (CPCH) or a random access channel (RACH) to access a specific UTRAN (or a base station in the CDMA-2000 system) which is comprised of the RNC and the base station transceivers (or the Node B), the RNC provides the UE and the base station transceivers with information about available uplink channel resources for the CPCH or RACH, i.e., information about an uplink scrambling code and an OVSF code. The OVSF code, which is a kind of orthogonal code, has the same function as the Walsh code used in the CDMA-2000 system, and the RNC provides the base station transceivers with available OVSF code node set information.
When the connection between the UE and the base station transceiver is made successfully, the UE continues communication with the base station transceiver using an downlink or uplink dedicated physical channel (DPCH). The W-CDMA system employs an asynchronous scheme in which the channels are not synchronized with the base station transceivers. In this case, each UE must be assigned its unique scrambling code so that the base station transceiver can distinguish the UE.
Therefore, an uplink synchronous transmission scheme (USTS) has been proposed. By using the USTS, it is possible to assign one scrambling code to a plurality of UEs. The USTS can assign a single identical scrambling code to a plurality of UEs by acquiring synchronization when the UTRAN (UMTS Terrestrial Radio Access Network) receives the uplink DPCHs from the UEs. As a result, the number of the scrambling codes allocated in one cell is decreased, thus reducing mutual interference between the UE signals. The UTRAN distinguishes the UEs each employing the USTS by using channelization codes provided form the RNC, i.e., the OVSF codes maintaining orthogonality among them. Herein, a set of the UEs which are assigned the single identical scrambling code will be defined as a “USTS group”, for convenience of explanation.
A process for acquiring uplink synchronization using the USTS scheme is divided into two processes, and the respective processes are described below.
A first process is an initial synchronization process, and in this process, the UTRAN receives a signal from the UE over the RACH and measures a difference between a time when the signal is received from the UE over the RACH and a predetermined reference time. Further, the UTRAN transmits the measured time difference to the UE over a forward access channel (FACH). Upon receipt of the time difference over the FACH, the UE aligns a transmission time using the time difference and acquires the initial synchronization.
A second process is a tracking process, and in this process, the UTRAN periodically compares the UE signal-received time with the reference time and transmits a time alignment bit to the UE through a transmit power control (TPC) bit on a control channel. Here, the time alignment bit is transmitted once per two frames, since it is transmitted through the TPC bit on the control channel. The time alignment bit can align the transmission time in a unit of n chips. In the case where the time alignment bit aligns the transmission time in a ⅛-chip unit, if the time alignment bit is ‘1’, the UE advances the transmission time by ⅛ chip. Otherwise, if the time alignment bit is ‘0’, the UE defers the transmission time by ⅛ chip.
Now, with reference to FIG. 2, a description will be made of the OVSF codes typically used for channel separation in the W-CDMA communication system.
The downlink can separate different channels using the OVSF codes, and the channels may have different data rates. Meanwhile, the uplink separates the respective channels in one UE, or separates the channels of the respective UEs in the USTS in which the UEs use the same scrambling code. The OVSF code Cn,k is uniquely determined according to a spreading factor (SF) ‘n’ and a code number ‘k’. In the OVSF code Cn,k, ‘n’ indicates an SF value and ‘k’ has a value of 0≦k≦SF−1. The OVSF code Cn,k is generated in accordance with Equation (1) below.                               C                      1            ,            0                          =                              1            ⁢                                                  [                                                                                C                                          2                      ,                      0                                                                                                                                        C                                          2                      ,                      1                                                                                            ]                    =                                    [                                                                                          C                                              1                        ,                        0                                                                                                                        C                                              1                        ,                        0                                                                                                                                                        C                                              1                        ,                        0                                                                                                                        -                                              C                                                  1                          ,                          0                                                                                                                                ]                        =                                                            [                                                                                    1                                                                    1                                                                                                            1                                                                                              -                          1                                                                                                      ]                                ⁢                                                                  [                                                                                                    C                                                                              2                                                          (                                                              n                                +                                1                                                            )                                                                                ,                          0                                                                                                                                                                        C                                                                              2                                                          (                                                              n                                +                                1                                                            )                                                                                ,                          1                                                                                                                                                                        C                                                                              2                                                          (                                                              n                                +                                1                                                            )                                                                                ,                          2                                                                                                                                                                        C                                                                              2                                                          (                                                              n                                +                                1                                                            )                                                                                ,                          3                                                                                                                                                                        •                        ⋯                                                                                                                                                C                                                                              2                                                          (                                                              n                                +                                1                                                            )                                                                                ,                                                                                    2                                                              (                                                                  n                                  +                                  1                                                                )                                                                                      -                            2                                                                                                                                                                                                  C                                                                              2                                                          (                                                              n                                +                                1                                                            )                                                                                ,                                                                                    2                                                              (                                                                  n                                  +                                  1                                                                )                                                                                      -                            1                                                                                                                                              ]                            =                              [                                                                                                    C                                                                              2                            n                                                    ,                          0                                                                                                                                    C                                                                              2                            n                                                    ,                          0                                                                                                                                                                        C                                                                              2                            n                                                    ,                          0                                                                                                                                    -                                                  C                                                                                    2                              n                                                        ,                            0                                                                                                                                                                                                  C                                                                              2                            n                                                    ,                          1                                                                                                                                    C                                                                              2                            n                                                    ,                          1                                                                                                                                                                        C                                                                              2                            n                                                    ,                          1                                                                                                                                    -                                                  C                                                                                    2                              n                                                        ,                            1                                                                                                                                                                                                  •                        ⋯                                                                                                            •                        ⋯                                                                                                                                                C                                                                              2                            n                                                    ,                                                                                    2                              n                                                        -                            1                                                                                                                                                              C                                                                              2                            n                                                    ,                                                                                    2                              n                                                        -                            1                                                                                                                                                                                                  C                                                                              2                            n                                                    ,                                                                                    2                              n                                                        -                            1                                                                                                                                                              -                                                  C                                                                                    2                              n                                                        ,                                                                                          2                                n                                                            -                              1                                                                                                                                                                          ]                                                                        Equation  (1)            
The OVSF codes of from SF=1 to SF=4, generated in accordance with Equation (1), can be expressed by Equation (2) below.
Equation (2)C1,0=(1)C2,0=(1, 1)C2,1=(1, −1)C4,0=(1, 1, 1, 1)C4,1=(1, 1, −1, −1) C4,2=(1, −1, 1, −1)C4,3=(1, −1, −1, 1)
FIG. 2 shows an OVSF code tree. In the following description, Cn,k in the OVSF code tree will be referred to as a “node”. For example, an OVSF code C1,0 will be referred to as “node C1,0” or “C1,0 node” in the OVSF code tree.
Referring to FIG. 2, a property of the OVSF codes will be described. Child nodes do not maintain orthogonality with their mother node. For example, if a node C4,0 is allocated to a specific channel, the child nodes or sub-nodes C8,0, C8,1, C16,0, C16,1, C16,2 and C16,3 of the mother node C4,0 cannot maintain orthogonality with all the mother nodes C2,0 and C1,0 corresponding to the mother node C4,0, when they are allocated to the different channels. In the following description, a term “sub-tree” refers to all the child nodes of a specific node. That is, when C4,0=(1, 1, 1, 1) of Equation (2) is allocated to a specific channel, the orthogonality is not maintained among C2,0=(1, 1), C8,0=(1, 1, 1, 1, 1, 1, 1, 1) and C8,1=(1, 1, 1, 1, −1, −1, −1, −1). Therefore, when the OVSF codes are allocated to the channels having different SF values (or having different data rates), the OVSF codes should be so allocated as to maintain orthogonality with the allocated OVSF codes.
Now, with reference to FIG. 3, a description will be made of a process for spreading a dedicated physical control channel (DPCCH) and a dedicated physical data channel (DPDCH) using the OVSF codes. In general, only one DPDCH is used for SF≧8, whereas a maximum of 6 DPDCHs can used for SF=4. As shown in FIG. 3, the channels can be divided into I-channel and Q-channel. Since the I-channel and the Q-channel can be separated by using a complex spreading code, they can be assigned the same channelization code. In FIG. 3, the DPCCH is assigned an OVSF code C256,0 and the 6 DPDCHs are assigned the following channelization codes:Cd,n=C4,kwhere, for n=1 or 2, k=1,                for n=3 or 4, k=3,        for n=5 or 6, k=2.        
In the UEs using the USTS, the RNC allocates one uplink scrambling code and available OVSF codes as resources for the DPCHs. The RNC allocates the OVSF codes to separate the DPDCHs (data part) using SF=4, SF=16, SF=32, SF=64, SF=128 and SF=256 necessary for one DPCH, and the DPCCH (control part) using SF=256. The RNC provides the corresponding base station transceiver(node B) and the UE with the node information for the OVSF code of the DPCH (DPDCH and DPCCH) through a message.
Now, we assume SF=64 is the lowest node for the convenience of explanation. An OVSF code tree with SF=64 will be described with reference to FIG. 4. when SF of the DPDCH is 4 and a node C4,1 is allocated in the OVSF code tree, the lowest node C64,15 of a node C4,0 belonging to the same mother node C2,0 as the node C4,1 is allocated as an OVSF code of the corresponding DPCCH. As another example, when SF of the DPDCH is 4 and a node C4,2 is allocated in the OVSF code tree, the lowest node C64,63 of a node C4,3 belonging to the same mother node C2,1 as the node C4,2 is allocated as an OVSF code of the corresponding DPCCH.
As described above, in every channel or service having a pair of the DPCCH with the fixed SF value and the DPDCH with the variable SF value, the conventional OVSF code allocation method has the following disadvantages.
Since a node of the DPCCH is always allocated in a pair with a node of the DPDCH, the number of the OVSF codes allocable to the DPDCH is decreased. That is, when a specific node is allocated to the data part in the OVSF code tree (i.e., when an OVSF code of a specific node is allocated to separate the DPDCH channel), the OVSF codes of all the child nodes belonging to the allocated specific node do not maintain orthogonality with the previously allocated node of the DPDCH. Therefore, it is not possible to simultaneously allocate the child nodes of the allocated specific node to the data part. That is, when a node C4,1 and a node C4,2 with SF=4 are allocated to the DPDCHs, a node C4,0 and a node C4,3 must be allocated to the DPCCHs corresponding to the DPDCHs. Therefore, it is not possible to allocate the OVSF code with SF=4 for the data part, so that in the OVSF code tree structure shown in FIG. 4 the data part can be allocated a maximum of 2 channels with SF=4.
The conventional OVSF code allocation method has a limitation on use of the OVSF code, since when one child node connected to a specific mother node is allocated to the data part, the remaining one child node is allocated to the control part. As a result, the channel allocation resources run short. In order to solve the OVSF code allocation limitation problem, it is possible to increase the number of the available OVSF codes for the DPDCH by separately providing an OVSF code allocation area for the DPCCH. For example, it is possible to provide a maximum of 3 channels, by using every OVSF code with SF=64 belonging to the mother node C4,0 only for the DPCCH and allocating the DPDCH to nodes C4,1, C4,2 and C4,3 for the data part with SF=4.